JavaScript Temporal Instant: didelio tikslumo laiko skaičiavimai

JavaScript jau seniai žinomas dėl savo ne pačių idealiausių datos ir laiko valdymo galimybių. Pasenęs Date objektas, nors ir plačiai naudojamas, kenčia nuo kintamumo, nenuoseklaus API elgesio ir prasto laiko juostų palaikymo. Pristatome Temporal API – modernų požiūrį į datos ir laiko manipuliavimą, sukurtą šiems trūkumams pašalinti. „Temporal“ pagrindas yra Instant objektas, atspindintis konkretų laiko momentą nanosekundžių tikslumu. Šiame tinklaraščio įraše pateikiamas išsamus vadovas, kaip naudoti Temporal.Instant didelio tikslumo laiko skaičiavimams jūsų JavaScript programose, atsižvelgiant į įvairius pasaulinės auditorijos poreikius.

Kas yra Temporal.Instant?

Temporal.Instant atspindi laiko momentą, matuojamą nuo Unix epochos (1970 m. sausio 1 d., 00:00:00 pasauliniu koordinuotuoju laiku (UTC)) nanosekundžių tikslumu. Skirtingai nuo pasenusio Date objekto, Temporal.Instant yra nekintamas, o tai reiškia, kad jo reikšmės negalima pakeisti po sukūrimo. Šis nekintamumas yra labai svarbus siekiant išvengti netikėtų šalutinių poveikių ir užtikrinti duomenų vientisumą, ypač sudėtingose programose.

Temporal.Instant objektų kūrimas

Yra keli būdai sukurti Temporal.Instant objektus:

1. Iš skaičiaus (milisekundės nuo epochos)

Galite sukurti Instant iš milisekundžių skaičiaus, praėjusio nuo Unix epochos. Tai panašu į tai, kaip veikia pasenęs Date objektas, tačiau Temporal.Instant siūlo didesnį tikslumą.

            
const instant = Temporal.Instant.fromEpochMilliseconds(1678886400000); // March 15, 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

2. Iš skaičiaus (nanosekundės nuo epochos)

Norėdami pasiekti dar didesnį tikslumą, galite sukurti Instant iš nanosekundžių skaičiaus, praėjusio nuo Unix epochos. Tai yra pats tiksliausias būdas pavaizduoti laiko momentą su Temporal.Instant.

            
const instant = Temporal.Instant.fromEpochNanoseconds(1678886400000000000n); // March 15, 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

Atkreipkite dėmesį į n priesagos naudojimą, nurodantį BigInt literalą. Nanosekundžių reikšmės dažnai viršija maksimalią saugią sveikojo skaičiaus reikšmę JavaScript skaičiams, todėl norint išsaugoti tikslumą būtina naudoti BigInt.

3. Iš ISO 8601 eilutės

Temporal.Instant taip pat gali būti sukurtas iš ISO 8601 eilutės, atspindinčios UTC datą ir laiką.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

const instantWithFractionalSeconds = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instantWithFractionalSeconds.toString()); // Output: 2023-03-15T00:00:00.123456789Z

            

              
                Copy
              
            
          

ISO 8601 eilutė turi baigtis Z, kad nurodytų UTC. Eilutėje pasirinktinai gali būti sekundės dalys su iki devynių skaitmenų tikslumu.

4. Iš Temporal.Now (sistemos laikrodis)

Dabartinį laiko momentą galite gauti naudodami Temporal.Now.instant():

            
const now = Temporal.Now.instant();
console.log(now.toString()); // Output: Varies depending on the current time

            

              
                Copy
              
            
          

Darbas su Temporal.Instant objektais

Sukūrę Temporal.Instant objektą, galite su juo atlikti įvairias operacijas. Atminkite, kad Temporal.Instant objektai yra nekintami, todėl šios operacijos grąžina naujus Temporal.Instant objektus, o ne keičia originalą.

1. Laiko pridėjimas ir atėmimas

Galite pridėti arba atimti laiką iš Instant naudodami add() ir subtract() metodus. Šie metodai priima Temporal.Duration objektą, kuris atspindi laiko tarpą.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });

const futureInstant = instant.add(duration);
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

const pastInstant = instant.subtract(duration);
console.log(pastInstant.toString()); // Output: 2023-03-14T21:30:00Z

            

              
                Copy
              
            
          

Taip pat galite naudoti eilutės vaizdavimą trukmei:

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const futureInstant = instant.add('PT2H30M'); // ISO 8601 duration string
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

            

              
                Copy
              
            
          

2. Momentų palyginimas

Galite palyginti du Temporal.Instant objektus naudodami compare() metodą. Šis metodas grąžina:

• -1, jei pirmasis momentas yra ankstesnis už antrąjį.
• 0, jei abu momentai yra lygūs.
• 1, jei pirmasis momentas yra vėlesnis už antrąjį.

            
const instant1 = Temporal.Instant.from('2023-03-15T00:00:00Z');
const instant2 = Temporal.Instant.from('2023-03-15T01:00:00Z');

console.log(Temporal.Instant.compare(instant1, instant2)); // Output: -1
console.log(Temporal.Instant.compare(instant2, instant1)); // Output: 1
console.log(Temporal.Instant.compare(instant1, instant1)); // Output: 0

            

              
                Copy
              
            
          

3. Konvertavimas į kitus Temporal tipus

Temporal.Instant galima konvertuoti į kitus Temporal tipus, tokius kaip Temporal.ZonedDateTime, Temporal.PlainDateTime ir Temporal.PlainDate. Tai būtina dirbant su laiko juostomis ir lokalizuotais datos bei laiko vaizdavimais.

a. Į Temporal.ZonedDateTime

Temporal.ZonedDateTime atspindi datą ir laiką su konkrečia laiko juosta. Norėdami konvertuoti Instant į ZonedDateTime, turite nurodyti laiko juostą.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTime.toString()); // Output: 2023-03-14T17:00:00-07:00[America/Los_Angeles]

            

              
                Copy
              
            
          

Metodas toZonedDateTimeISO() sukuria ZonedDateTime naudodamas ISO 8601 kalendorių. Taip pat galite naudoti toZonedDateTime(), kad nurodytumėte kitą kalendorių.

b. Į Temporal.PlainDateTime

Temporal.PlainDateTime atspindi datą ir laiką be laiko juostos. Norėdami konvertuoti Instant į PlainDateTime, pirmiausia turite jį konvertuoti į ZonedDateTime, o tada iš jo gauti PlainDateTime.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDateTime = zonedDateTime.toPlainDateTime();
console.log(plainDateTime.toString()); // Output: 2023-03-14T17:00:00

            

              
                Copy
              
            
          

c. Į Temporal.PlainDate

Temporal.PlainDate atspindi datą be laiko ar laiko juostos. Panašiai kaip su PlainDateTime, pirmiausia konvertuojate į ZonedDateTime.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDate = zonedDateTime.toPlainDate();
console.log(plainDate.toString()); // Output: 2023-03-14

            

              
                Copy
              
            
          

4. Milisekundžių ir nanosekundžių nuo epochos gavimas

Galite gauti milisekundžių ar nanosekundžių skaičių, praėjusį nuo Unix epochos, naudodami atitinkamai epochMilliseconds ir epochNanoseconds savybes.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instant.epochMilliseconds); // Output: 1678886400123
console.log(instant.epochNanoseconds); // Output: 1678886400123456789n

            

              
                Copy
              
            
          

Temporal.Instant naudojimo atvejai

Temporal.Instant yra ypač naudingas tais atvejais, kai reikalingi didelio tikslumo laiko skaičiavimai. Štai keli pavyzdžiai:

1. Įvykių registravimas ir auditas

Registruojant įvykius ar atliekant sistemos veiklos auditą, labai svarbu užfiksuoti tikslų įvykio laiką. Temporal.Instant suteikia reikiamą tikslumą, kad būtų galima tiksliai įrašyti laiko žymes.

            
function logEvent(eventDescription) {
  const timestamp = Temporal.Now.instant().toString();
  console.log(`[${timestamp}] ${eventDescription}`);
}

logEvent('User logged in');
logEvent('File saved');

            

              
                Copy
              
            
          

2. Našumo matavimas

Norint išmatuoti kodo našumą, reikalingas tikslus laiko matavimas. Temporal.Instant gali būti naudojamas kodo blokų vykdymo laikui matuoti nanosekundžių tikslumu.

            
const start = Temporal.Now.instant();
// Code to measure
for (let i = 0; i < 1000000; i++) {
  // Some operation
}
const end = Temporal.Now.instant();

const duration = end.since(start);
console.log(`Execution time: ${duration.total('milliseconds')} milliseconds`);

            

              
                Copy
              
            
          

3. Paskirstytosios sistemos ir duomenų sinchronizavimas

Paskirstytosiose sistemose, siekiant išlaikyti duomenų nuoseklumą tarp kelių mazgų, dažnai reikalingas tikslus laiko sinchronizavimas. Temporal.Instant gali būti naudojamas atvaizduoti duomenų atnaujinimų laiko žymes ir spręsti konfliktus pagal laiką.

Pavyzdžiui, apsvarstykite scenarijų, kai duomenys yra replikuojami keliuose serveriuose skirtingose geografinėse vietose (pvz., turinio pristatymo tinkle ar paskirstyotoje duomenų bazėje). Jei vartotojas atnaujina įrašą, sistema turi užtikrinti, kad naujausias atnaujinimas būtų nuosekliai išplatintas visuose serveriuose. Naudojant Temporal.Instant kiekvieno atnaujinimo laiko žymei, užtikrinamas tikslus eiliškumas, net esant tinklo delsai ir galimam laikrodžių nuokrypiui tarp serverių.

4. Finansinės operacijos

Finansinėms operacijoms dažnai reikalingos didelio tikslumo laiko žymės, siekiant laikytis teisės aktų reikalavimų ir užtikrinti tikslią apskaitą. Tikslus prekybos, mokėjimo ar pervedimo laikas turi būti tiksliai užfiksuotas, kad būtų išvengta ginčų ir užtikrinta atskaitomybė.

Pavyzdžiui, aukšto dažnio prekybos sistemos reikalauja mikrosekundžių ar nanosekundžių tikslumo, kad būtų užfiksuotas tikslus pavedimo įvykdymo momentas. Net maži laiko neatitikimai gali sukelti didelių finansinių pasekmių. Temporal.Instant suteikia reikiamą skiriamąją gebą šioms kritinėms programoms.

5. Mokslinės programos

Daugeliui mokslinių programų, tokių kaip astronomija, fizikos simuliacijos ir duomenų registravimas iš eksperimentų, reikalingi labai tikslūs laiko matavimai. Šie matavimai dažnai yra labai svarbūs analizuojant duomenis ir darant tikslias išvadas.

Įsivaizduokite teleskopą, fiksuojantį duomenis iš tolimos žvaigždės. Tikslus kiekvieno stebėjimo laikas yra būtinas norint nustatyti žvaigždės padėtį, judėjimą ir kitas savybes. Temporal.Instant leidžia mokslininkams įrašyti šias laiko žymes su reikiamu tikslumu.

Internacionalizacija ir laiko juostos

Nors Temporal.Instant atspindi laiko momentą UTC formatu, svarbu atsižvelgti į laiko juostas dirbant su datomis ir laikais, skirtais pasaulinei auditorijai. Kaip parodyta anksčiau, galite konvertuoti Instant į Temporal.ZonedDateTime, kad atspindėtumėte tą patį laiko momentą konkrečioje laiko juostoje.

Rodant datas ir laikus vartotojams, visada naudokite jų vietinę laiko juostą, kad išvengtumėte nesusipratimų. Vartotojo laiko juostą galite gauti iš jo naršyklės ar operacinės sistemos. Pavyzdžiui, galite naudoti Intl.DateTimeFormat API, kad suformatuotumėte datą ir laiką pagal vartotojo lokalę ir laiko juostą.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO(Temporal.Now.timeZone());

const formatter = new Intl.DateTimeFormat(undefined, {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  timeZoneName: 'short',
});

console.log(formatter.format(zonedDateTime)); // Output: Varies depending on the user's locale and time zone

            

              
                Copy
              
            
          

Šiame pavyzdyje naudojama vartotojo sistemos laiko juosta. Jei reikia, galite pakeisti Temporal.Now.timeZone() konkrečiu laiko juostos identifikatoriumi (pvz., 'America/Los_Angeles').

Pastaba: Dirbdami su laiko juostomis, visada atsižvelkite į vasaros laiką (DST). Laiko juostų taisyklės gali keistis, todėl svarbu naudoti naujausią laiko juostų duomenų bazę, kad būtų užtikrinti tikslūs skaičiavimai. „Temporal“ API automatiškai tvarko DST perėjimus konvertuojant tarp laiko juostų.

Naršyklių ir aplinkos palaikymas

2023 m. pabaigoje „Temporal“ API vis dar yra gana naujas ir dar nevisiškai palaikomas visose naršyklėse ir JavaScript aplinkose. Gali prireikti naudoti polifilą (polyfill), kad būtų užtikrintas palaikymas senesnėms naršyklėms.

Paketas @js-temporal/polyfill suteikia polifilą „Temporal“ API. Galite jį įdiegti naudodami npm arba yarn:

            
npm install @js-temporal/polyfill

            

              
                Copy
              
            
          

Tada importuokite polifilą savo JavaScript kode:

            
import '@js-temporal/polyfill';

            

              
                Copy
              
            
          

Tai pridės „Temporal“ API į globalią sritį, leisdama jį naudoti savo kode, net jei aplinka jo natūraliai nepalaiko.

Geroji praktika ir svarstymai

• Naudokite UTC vidiniam saugojimui ir skaičiavimams: Saugokite visas laiko žymes UTC formatu, kad išvengtumėte su laiko juostomis susijusių problemų. Konvertuokite į vietines laiko juostas tik rodydami datas ir laikus vartotojams.
• Atsargiai tvarkykite laiko juostų konversijas: Žinokite apie DST ir laiko juostų taisyklių pasikeitimus. Naudokite naujausią laiko juostų duomenų bazę, kad užtikrintumėte tikslias konversijas.
• Naudokite BigInt nanosekundžių reikšmėms: Nanosekundžių reikšmės dažnai viršija maksimalią saugią sveikojo skaičiaus reikšmę JavaScript skaičiams. Naudokite BigInt tikslumui išsaugoti.
• Apsvarstykite polifilo naudojimą: Jei reikia palaikyti senesnes naršykles ar aplinkas, naudokite @js-temporal/polyfill paketą.
• Kruopščiai testuokite savo kodą: Išbandykite savo kodą su skirtingomis laiko juostomis ir lokalėmis, kad įsitikintumėte, jog jis veikia teisingai visiems vartotojams.
• Dokumentuokite savo prielaidas: Aiškiai dokumentuokite visas prielaidas, kurias darote apie laiko juostas, lokales ar datos ir laiko formatus.

Išvada

Temporal.Instant suteikia tvirtą ir tikslų būdą atvaizduoti laiko momentus JavaScript. Jo nekintamumas, nanosekundžių tikslumas ir integracija su kitais Temporal tipais daro jį galingu įrankiu sudėtingiems laiko skaičiavimams įvairiose programose. Suprasdami, kaip kurti, manipuliuoti ir lyginti Instant objektus, ir laikydamiesi gerosios internacionalizacijos bei laiko juostų valdymo praktikos, galite sukurti patikimą ir tikslią datos bei laiko funkcionalumą pasaulinei auditorijai. Priėmus „Temporal“ API, įskaitant Instant objektą, kūrėjai gali peržengti pasenusio Date objekto apribojimus ir kurti tvirtesnes bei lengviau prižiūrimas programas, kurios tiksliai atspindi laiko sudėtingumą skirtingose kultūrose ir regionuose.

„Temporal“ API vis plačiau prigyja, todėl tikimasi, kad jis taps datos ir laiko manipuliavimo standartu JavaScript. Kūrėjai, susipažinę su jo ypatybėmis ir gerąja praktika, bus gerai pasirengę kurti naujos kartos laiko atžvilgiu sąmoningas programas.